home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / comm2 / termsorc.lha / Extras / Source / term-source.lha / termOldConfig.c < prev    next >
C/C++ Source or Header  |  1995-09-26  |  19KB  |  860 lines
  1. /*
  2. **    termOldConfig.c
  3. **
  4. **    Old configuration processing routines
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. struct OldSerialSettings
  13. {
  14.     ULONG    BaudRate;
  15.     ULONG    BreakLength;
  16.     ULONG    SerialBufferSize;
  17.  
  18.     UBYTE    SerialDevice[256];
  19.     LONG    UnitNumber;
  20.  
  21.     BYTE    BitsPerChar;
  22.     BYTE    Parity;
  23.     BYTE    StopBits;
  24.     BYTE    HandshakingProtocol;
  25.     BYTE    Duplex;
  26.  
  27.     BYTE    xONxOFF;
  28.     BYTE    HighSpeed;
  29.     BYTE    Shared;
  30.     BYTE    StripBit8;
  31.     BYTE    CheckCarrier;
  32.     BYTE    PassThrough;
  33. };
  34.  
  35. struct OldModemSettings
  36. {
  37.     UBYTE    ModemInit[80];
  38.     UBYTE     ModemExit[80];
  39.     UBYTE     ModemHangup[80];
  40.     UBYTE    DialPrefix[80];
  41.     UBYTE    DialSuffix[80];
  42.  
  43.     UBYTE    NoCarrier[16];
  44.     UBYTE    NoDialTone[16];
  45.     UBYTE    Connect[16];
  46.     UBYTE    Voice[16];
  47.     UBYTE    Ring[16];
  48.     UBYTE    Busy[16];
  49.  
  50.     LONG    RedialDelay;
  51.     LONG    DialRetries;
  52.     LONG    DialTimeout;
  53.     BYTE    ConnectAutoBaud;
  54.     BYTE    DropDTR;
  55. };
  56.  
  57. struct OldCommandSettings
  58. {
  59.     UBYTE    StartupMacro[256];
  60.     UBYTE    LogoffMacro[256];
  61.     UBYTE    UploadMacro[256];
  62.     UBYTE    DownloadMacro[256];
  63. };
  64.  
  65. struct OldScreenSettings
  66. {
  67.     ULONG    DisplayMode;
  68.     WORD    ColourMode;
  69.     UWORD    Colours[16];
  70.     UBYTE    FontName[256];
  71.     WORD    FontHeight;
  72.  
  73.     BYTE    MakeScreenPublic;
  74.     BYTE    ShanghaiWindows;
  75.  
  76.     BYTE    Blinking;
  77.     BYTE    FasterLayout;
  78.     BYTE    TitleBar;
  79.     BYTE    StatusLine;
  80. };
  81.  
  82. struct OldTerminalSettings
  83. {
  84.     BYTE    BellMode;
  85.     BYTE    AlertMode;
  86.     BYTE    EmulationMode;
  87.     BYTE    FontMode;
  88.  
  89.     BYTE    SendCR;
  90.     BYTE    SendLF;
  91.     BYTE    ReceiveCR;
  92.     BYTE    ReceiveLF;
  93.  
  94.     UWORD    NumColumns,
  95.         NumLines;
  96.  
  97.     UBYTE    KeyMapFileName[256];
  98.     UBYTE    EmulationFileName[256];
  99.     UBYTE    BeepFileName[256];
  100.  
  101.     UBYTE    TextFontName[256];
  102.     WORD    TextFontHeight;
  103. };
  104.  
  105. struct OldPathSettings
  106. {
  107.     UBYTE    ASCIIUploadPath[256];
  108.     UBYTE    ASCIIDownloadPath[256];
  109.  
  110.     UBYTE    TextUploadPath[256];
  111.     UBYTE    TextDownloadPath[256];
  112.  
  113.     UBYTE    BinaryUploadPath[256];
  114.     UBYTE    BinaryDownloadPath[256];
  115.  
  116.     UBYTE    DefaultStorage[256];
  117.  
  118.     UBYTE    Editor[256];
  119. };
  120.  
  121. struct OldMiscSettings
  122. {
  123.     BYTE    Priority;
  124.     BYTE    BackupConfig;
  125.  
  126.     BYTE    OpenFastMacroPanel;
  127.     BYTE    ReleaseDevice;
  128.  
  129.     BYTE    TransferServer;
  130.     BYTE    EmulationServer;
  131.  
  132.     BYTE    OverridePath;
  133.     BYTE    AutoUpload;
  134.     BYTE    SetArchivedBit;
  135.     BYTE    IdentifyFiles;
  136. };
  137.  
  138. struct OldClipSettings
  139. {
  140.     WORD    ClipboardUnit;
  141.  
  142.     WORD    LineDelay,
  143.         CharDelay;
  144.  
  145.     UBYTE    InsertPrefix[80];
  146.     UBYTE    InsertSuffix[80];
  147. };
  148.  
  149. struct OldCaptureSettings
  150. {
  151.     BYTE    LogActions;
  152.     BYTE    LogCall;
  153.     UBYTE    LogFileName[256];
  154.  
  155.     LONG    MaxBufferSize;
  156.     BYTE    BufferEnabled;
  157.  
  158.     BYTE    ConnectAutoCapture;
  159.     BYTE    CaptureFilterMode;
  160.     UBYTE    CapturePath[256];
  161. };
  162.  
  163. struct OldFileSettings
  164. {
  165.     UBYTE    ProtocolFileName[256];
  166.     UBYTE    TranslationFileName[256];
  167.     UBYTE    MacroFileName[256];
  168.     UBYTE    CursorFileName[256];
  169.     UBYTE    FastMacroFileName[256];
  170. };
  171.  
  172. struct OldEmulationSettings
  173. {
  174.     BYTE    CursorMode;
  175.     BYTE    NumericMode;
  176.  
  177.     BYTE    CursorWrap;
  178.     BYTE    LineWrap;
  179.  
  180.     BYTE    InsertMode;
  181.     BYTE    NewLineMode;
  182.  
  183.     BYTE    FontScale;
  184.     BYTE    ScrollMode;
  185.     BYTE    DestructiveBackspace;
  186.     BYTE    SwapBSDelete;
  187.     BYTE    PrinterEnabled;
  188.     BYTE    Pad;
  189.  
  190.     UBYTE    AnswerBack[80];
  191. };
  192.  
  193. struct OldConfiguration
  194. {
  195.     struct OldSerialSettings    SerialConfig;
  196.     struct OldModemSettings        ModemConfig;
  197.     struct OldScreenSettings    ScreenConfig;
  198.     struct OldTerminalSettings    TerminalConfig;
  199.     struct OldEmulationSettings    EmulationConfig;
  200.     struct OldClipSettings        ClipConfig;
  201.     struct OldCaptureSettings    CaptureConfig;
  202.     struct OldCommandSettings    CommandConfig;
  203.     struct OldMiscSettings        MiscConfig;
  204.     struct OldPathSettings        PathConfig;
  205.     struct OldFileSettings        FileConfig;
  206. };
  207.  
  208. struct OldPhoneHeader
  209. {
  210.     UBYTE    Name[40],        /* BBS name. */
  211.         Number[60],        /* Phone number. */
  212.         Comment[40];        /* Comment. */
  213.  
  214.     UBYTE    UserName[30],        /* User name for this BSS. */
  215.         Password[30];        /* Password for user name. */
  216. };
  217.  
  218.     /* ConvertHeader():
  219.      *
  220.      *    Convert old style phone book header to new style
  221.      *    phone book header.
  222.      */
  223.  
  224. STATIC VOID __regargs
  225. ConvertHeader(struct OldPhoneHeader *OldHeader,struct PhoneHeader *NewHeader)
  226. {
  227.     strcpy(NewHeader -> Name,    OldHeader -> Name);
  228.     strcpy(NewHeader -> Number,    OldHeader -> Number);
  229.     strcpy(NewHeader -> Comment,    OldHeader -> Comment);
  230.  
  231.     strcpy(NewHeader -> UserName,    OldHeader -> UserName);
  232.     strcpy(NewHeader -> Password,    OldHeader -> Password);
  233. }
  234.  
  235.     /* ConvertConfig():
  236.      *
  237.      *    Convert old style configuration to new style configuration.
  238.      */
  239.  
  240. STATIC BYTE __regargs
  241. ConvertConfig(struct OldConfiguration *OldConfig,struct Configuration *NewConfig,BOOLEAN IsPhonebook)
  242. {
  243.     if(CreateConfigEntry(NewConfig,PREF_SERIAL))
  244.     {
  245.         ResetConfigEntry(NewConfig,PREF_SERIAL,FALSE);
  246.  
  247.         memcpy(NewConfig -> SerialConfig,&OldConfig -> SerialConfig,MIN(sizeof(struct SerialSettings),sizeof(struct OldSerialSettings)));
  248.  
  249.         FixOldConfig(NewConfig,PREF_SERIAL,IsPhonebook,2,4);
  250.     }
  251.     else
  252.         return(FALSE);
  253.  
  254.     if(CreateConfigEntry(NewConfig,PREF_MODEM))
  255.     {
  256.         ResetConfigEntry(NewConfig,PREF_MODEM,FALSE);
  257.  
  258.         memcpy(NewConfig -> ModemConfig,&OldConfig -> ModemConfig,MIN(sizeof(struct ModemSettings),sizeof(struct OldModemSettings)));
  259.  
  260.         FixOldConfig(NewConfig,PREF_MODEM,IsPhonebook,2,4);
  261.     }
  262.     else
  263.         return(FALSE);
  264.  
  265.     if(CreateConfigEntry(NewConfig,PREF_COMMAND))
  266.     {
  267.         ResetConfigEntry(NewConfig,PREF_COMMAND,FALSE);
  268.  
  269.         memcpy(NewConfig -> CommandConfig,&OldConfig -> CommandConfig,MIN(sizeof(struct CommandSettings),sizeof(struct OldCommandSettings)));
  270.  
  271.         FixOldConfig(NewConfig,PREF_COMMAND,IsPhonebook,2,4);
  272.     }
  273.     else
  274.         return(FALSE);
  275.  
  276.     if(CreateConfigEntry(NewConfig,PREF_SCREEN))
  277.     {
  278.         ResetConfigEntry(NewConfig,PREF_SCREEN,FALSE);
  279.  
  280.         memcpy(NewConfig -> ScreenConfig,&OldConfig -> ScreenConfig,MIN(sizeof(struct ScreenSettings),sizeof(struct OldScreenSettings)));
  281.  
  282.         FixOldConfig(NewConfig,PREF_SCREEN,IsPhonebook,2,4);
  283.     }
  284.     else
  285.         return(FALSE);
  286.  
  287.     if(CreateConfigEntry(NewConfig,PREF_TERMINAL))
  288.     {
  289.         ResetConfigEntry(NewConfig,PREF_TERMINAL,FALSE);
  290.  
  291.         memcpy(NewConfig -> TerminalConfig,&OldConfig -> TerminalConfig,MIN(sizeof(struct TerminalSettings),sizeof(struct OldTerminalSettings)));
  292.  
  293.         FixOldConfig(NewConfig,PREF_TERMINAL,IsPhonebook,2,4);
  294.     }
  295.     else
  296.         return(FALSE);
  297.  
  298.     if(CreateConfigEntry(NewConfig,PREF_PATH))
  299.     {
  300.         ResetConfigEntry(NewConfig,PREF_PATH,FALSE);
  301.  
  302.         memcpy(NewConfig -> PathConfig,&OldConfig -> PathConfig,MIN(sizeof(struct PathSettings),sizeof(struct OldPathSettings)));
  303.  
  304.         FixOldConfig(NewConfig,PREF_PATH,IsPhonebook,2,4);
  305.     }
  306.     else
  307.         return(FALSE);
  308.  
  309.     if(CreateConfigEntry(NewConfig,PREF_MISC))
  310.     {
  311.         ResetConfigEntry(NewConfig,PREF_MISC,FALSE);
  312.  
  313.         memcpy(NewConfig -> MiscConfig,&OldConfig -> MiscConfig,MIN(sizeof(struct MiscSettings),sizeof(struct OldMiscSettings)));
  314.  
  315.         FixOldConfig(NewConfig,PREF_MISC,IsPhonebook,2,4);
  316.     }
  317.     else
  318.         return(FALSE);
  319.  
  320.     if(CreateConfigEntry(NewConfig,PREF_CLIP))
  321.     {
  322.         ResetConfigEntry(NewConfig,PREF_CLIP,FALSE);
  323.  
  324.         memcpy(NewConfig -> ClipConfig,&OldConfig -> ClipConfig,MIN(sizeof(struct ClipSettings),sizeof(struct OldClipSettings)));
  325.  
  326.         FixOldConfig(NewConfig,PREF_CLIP,IsPhonebook,2,4);
  327.     }
  328.     else
  329.         return(FALSE);
  330.  
  331.     if(CreateConfigEntry(NewConfig,PREF_CAPTURE))
  332.     {
  333.         ResetConfigEntry(NewConfig,PREF_CAPTURE,FALSE);
  334.  
  335.         memcpy(NewConfig -> CaptureConfig,&OldConfig -> CaptureConfig,MIN(sizeof(struct CaptureSettings),sizeof(struct OldCaptureSettings)));
  336.  
  337.         strcpy(NewConfig -> CaptureConfig -> CallLogFileName,NewConfig -> CaptureConfig -> LogFileName);
  338.  
  339.         AddPart(NewConfig -> CaptureConfig -> CallLogFileName,"term-call.log",MAX_FILENAME_LENGTH);
  340.  
  341.         FixOldConfig(NewConfig,PREF_CAPTURE,IsPhonebook,2,4);
  342.     }
  343.     else
  344.         return(FALSE);
  345.  
  346.     if(CreateConfigEntry(NewConfig,PREF_FILE))
  347.     {
  348.         LONG i,Error = 0;
  349.  
  350.         ResetConfigEntry(NewConfig,PREF_FILE,FALSE);
  351.  
  352.         memcpy(NewConfig -> FileConfig,&OldConfig -> FileConfig,MIN(sizeof(struct FileSettings),sizeof(struct OldFileSettings)));
  353.  
  354.         FixOldConfig(NewConfig,PREF_FILE,IsPhonebook,2,4);
  355.  
  356.         for(i = PREF_TRANSLATIONFILENAME ; i <= PREF_FASTMACROFILENAME ; i++)
  357.         {
  358.             if(!CreateConfigEntry(NewConfig,i))
  359.             {
  360.                 Error = ERROR_NO_FREE_STORE;
  361.                 break;
  362.             }
  363.         }
  364.  
  365.         if(!Error)
  366.         {
  367.             strcpy(NewConfig -> TranslationFileName,    NewConfig -> FileConfig -> TranslationFileName);
  368.             strcpy(NewConfig -> MacroFileName,        NewConfig -> FileConfig -> MacroFileName);
  369.             strcpy(NewConfig -> CursorFileName,        NewConfig -> FileConfig -> CursorFileName);
  370.             strcpy(NewConfig -> FastMacroFileName,        NewConfig -> FileConfig -> FastMacroFileName);
  371.  
  372.             DeleteConfigEntry(NewConfig,PREF_FILE);
  373.         }
  374.         else
  375.         {
  376.             SetIoErr(Error);
  377.             return(FALSE);
  378.         }
  379.     }
  380.     else
  381.         return(FALSE);
  382.  
  383.     if(CreateConfigEntry(NewConfig,PREF_EMULATION))
  384.     {
  385.         ResetConfigEntry(NewConfig,PREF_EMULATION,FALSE);
  386.  
  387.         memcpy(NewConfig -> EmulationConfig,&OldConfig -> EmulationConfig,MIN(sizeof(struct EmulationSettings),sizeof(struct OldEmulationSettings)));
  388.  
  389.         FixOldConfig(NewConfig,PREF_EMULATION,IsPhonebook,2,4);
  390.     }
  391.     else
  392.         return(FALSE);
  393.  
  394.     FinalFix(NewConfig,IsPhonebook,2,4);
  395.  
  396.     return(TRUE);
  397. }
  398.  
  399.     /* LoadOldPhonebook(STRPTR Name):
  400.      *
  401.      *    Restore a phone book from a disk file.
  402.      */
  403.  
  404. BYTE __regargs
  405. LoadOldPhonebook(STRPTR Name,PhonebookHandle *BookHandle)
  406. {
  407.     STATIC ULONG Stops[6 * 2] =
  408.     {
  409.         ID_TERM,ID_VERS,
  410.         ID_TERM,ID_DIAL,
  411.         ID_TERM,ID_PREF,
  412.         ID_TERM,ID_DATE,
  413.         ID_TERM,ID_PHON,
  414.         ID_TERM,ID_PSWD
  415.     };
  416.  
  417.     struct PhoneEntry    **PrivatePhonebook;
  418.     LONG             PrivatePhoneSize = 0;
  419.     LONG             Size = 0,Count = 0,Last = -1;
  420.     struct IFFHandle    *Handle;
  421.     BYTE             Success = FALSE;
  422.     struct ContextNode    *Chunk;
  423.     BYTE             LastHadTime    = TRUE,
  424.                  HadPassword    = FALSE;
  425.     struct TimeDateNode    *TimeDateNode;
  426.     struct OldConfiguration    *OldConfig;
  427.     struct OldPhoneHeader    *OldHeader;
  428.     LONG             Error;
  429.  
  430.     if(OldConfig = (struct OldConfiguration *)AllocVecPooled(sizeof(struct OldConfiguration) + sizeof(struct OldPhoneHeader),MEMF_ANY))
  431.     {
  432.         OldHeader = (struct OldPhoneHeader *)(OldConfig + 1);
  433.  
  434.         if(Handle = AllocIFF())
  435.         {
  436.             if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  437.             {
  438.                 InitIFFasDOS(Handle);
  439.  
  440.                 if(!(Error = OpenIFF(Handle,IFFF_READ)))
  441.                 {
  442.                     if(!(Error = StopChunks(Handle,(LONG *)Stops,6)))
  443.                     {
  444.                         while(!ParseIFF(Handle,IFFPARSE_SCAN))
  445.                         {
  446.                             Chunk = CurrentChunk(Handle);
  447.  
  448.                             if(Chunk -> cn_ID == ID_VERS)
  449.                             {
  450.                                 struct TermInfo TermInfo;
  451.  
  452.                                 if(ReadChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  453.                                 {
  454.                                     if(TermInfo . Version != 2 || TermInfo . Revision != 4)
  455.                                     {
  456.                                         Error = ERR_OUTDATED;
  457.  
  458.                                         break;
  459.                                     }
  460.                                 }
  461.                                 else
  462.                                 {
  463.                                     Error = IoErr();
  464.  
  465.                                     break;
  466.                                 }
  467.                             }
  468.  
  469.                             if(Chunk -> cn_ID == ID_PSWD)
  470.                             {
  471.                                 UBYTE DummyBuffer[20];
  472.  
  473.                                 HadPassword = TRUE;
  474.  
  475.                                 if(ReadChunkBytes(Handle,DummyBuffer,20) == 20)
  476.                                 {
  477.                                     if(BookHandle)
  478.                                     {
  479.                                         if(BookHandle -> PhonePasswordUsed)
  480.                                         {
  481.                                             if(!memcmp(BookHandle -> PhonePassword,DummyBuffer,20))
  482.                                                 continue;
  483.                                         }
  484.                                     }
  485.                                     else
  486.                                     {
  487.                                         if(PhonePasswordUsed)
  488.                                         {
  489.                                             if(!memcmp(PhonePassword,DummyBuffer,20))
  490.                                                 continue;
  491.                                         }
  492.                                     }
  493.  
  494.                                     memset(SharedBuffer,0,21);
  495.  
  496.                                     if(GetString(FALSE,TRUE,21,LocaleString(MSG_PHONEPANEL_PLEASE_ENTER_PASSWORD_TXT),SharedBuffer))
  497.                                     {
  498.                                         UBYTE AnotherBuffer[20];
  499.  
  500.                                         Encrypt(SharedBuffer,20,AnotherBuffer,SharedBuffer,strlen(SharedBuffer));
  501.  
  502.                                         if(!memcmp(DummyBuffer,AnotherBuffer,20))
  503.                                         {
  504.                                             if(BookHandle)
  505.                                             {
  506.                                                 memcpy(BookHandle -> PhonePassword,DummyBuffer,20);
  507.  
  508.                                                 BookHandle -> PhonePasswordUsed = TRUE;
  509.                                             }
  510.                                             else
  511.                                             {
  512.                                                 memcpy(PhonePassword,DummyBuffer,20);
  513.  
  514.                                                 PhonePasswordUsed = TRUE;
  515.                                             }
  516.  
  517.                                             continue;
  518.                                         }
  519.                                         else
  520.                                         {
  521.                                             MyEasyRequest(Window,LocaleString(MSG_TERMPHONE_WRONG_PASSWORD_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),Name);
  522.  
  523.                                             break;
  524.                                         }
  525.                                     }
  526.                                     else
  527.                                         break;
  528.                                 }
  529.                                 else
  530.                                 {
  531.                                     Error = IoErr();
  532.  
  533.                                     break;
  534.                                 }
  535.                             }
  536.  
  537.                             if(Chunk -> cn_ID == ID_DIAL)
  538.                             {
  539.                                 if(ReadChunkBytes(Handle,&Size,sizeof(LONG)) == sizeof(LONG))
  540.                                 {
  541.                                     if(!(PrivatePhonebook = CreatePhonebook(Size,&PrivatePhoneSize,TRUE)))
  542.                                         break;
  543.                                 }
  544.                                 else
  545.                                 {
  546.                                     Error = IoErr();
  547.  
  548.                                     break;
  549.                                 }
  550.                             }
  551.  
  552.                             if(Chunk -> cn_ID == ID_PHON)
  553.                             {
  554.                                 WORD Size = MIN(sizeof(struct OldPhoneHeader),Chunk -> cn_Size);
  555.  
  556.                                 if(ReadChunkBytes(Handle,OldHeader,Size) == Size)
  557.                                 {
  558.                                     if(BookHandle)
  559.                                     {
  560.                                         if(BookHandle -> PhonePasswordUsed)
  561.                                             Decrypt((UBYTE *)OldHeader,Size,(UBYTE *)OldHeader,BookHandle -> PhonePassword,20);
  562.                                     }
  563.                                     else
  564.                                     {
  565.                                         if(PhonePasswordUsed)
  566.                                             Decrypt((UBYTE *)OldHeader,Size,(UBYTE *)OldHeader,PhonePassword,20);
  567.                                     }
  568.                                 }
  569.                                 else
  570.                                 {
  571.                                     Error = IoErr();
  572.  
  573.                                     break;
  574.                                 }
  575.                             }
  576.  
  577.                             if(Chunk -> cn_ID == ID_PREF)
  578.                             {
  579.                                 if(Last != -1)
  580.                                 {
  581.                                     if(!LastHadTime)
  582.                                     {
  583.                                         if(TimeDateNode = CreateTimeDateNode(-1,-1,"",2))
  584.                                             AddTail((struct List *)&PrivatePhonebook[Last] -> TimeDateList,&TimeDateNode -> VanillaNode);
  585.                                     }
  586.                                 }
  587.  
  588.                                 if(Size && Count < Size)
  589.                                 {
  590.                                     WORD LastSize = MIN(Chunk -> cn_Size,sizeof(struct OldConfiguration));
  591.  
  592.                                     if(BookHandle)
  593.                                         BookHandle -> PhonePasswordUsed = HadPassword;
  594.                                     else
  595.                                         PhonePasswordUsed = HadPassword;
  596.  
  597.                                     if(ReadChunkBytes(Handle,OldConfig,LastSize) == LastSize)
  598.                                     {
  599.                                         if(BookHandle)
  600.                                         {
  601.                                             if(BookHandle -> PhonePasswordUsed)
  602.                                                 Decrypt((UBYTE *)OldConfig,LastSize,(UBYTE *)OldConfig,BookHandle -> PhonePassword,20);
  603.                                         }
  604.                                         else
  605.                                         {
  606.                                             if(PhonePasswordUsed)
  607.                                                 Decrypt((UBYTE *)OldConfig,LastSize,(UBYTE *)OldConfig,PhonePassword,20);
  608.                                         }
  609.  
  610.                                         if(ConvertConfig(OldConfig,PrivatePhonebook[Count] -> Config,TRUE))
  611.                                         {
  612.                                             memset(PrivatePhonebook[Count] -> Header,0,sizeof(struct PhoneHeader));
  613.  
  614.                                             ConvertHeader(OldHeader,PrivatePhonebook[Count] -> Header);
  615.  
  616.                                             Last = Count;
  617.  
  618.                                             PrivatePhonebook[Count] -> Count = -1;
  619.  
  620.                                             Count++;
  621.  
  622.                                             LastHadTime = FALSE;
  623.                                         }
  624.                                         else
  625.                                         {
  626.                                             if(Count)
  627.                                                 Size = Count - 1;
  628.                                             else
  629.                                                 Size = 0;
  630.  
  631.                                             break;
  632.                                         }
  633.                                     }
  634.                                     else
  635.                                     {
  636.                                         Error = IoErr();
  637.  
  638.                                         if(Count)
  639.                                             Size = Count - 1;
  640.                                         else
  641.                                             Size = 0;
  642.  
  643.                                         break;
  644.                                     }
  645.                                 }
  646.                             }
  647.  
  648.                             if(Chunk -> cn_ID == ID_DATE)
  649.                             {
  650.                                 if(Last != -1)
  651.                                 {
  652.                                     WORD Count = (Chunk -> cn_Size - sizeof(struct TimeDateHeader)) / sizeof(struct TimeDate);
  653.  
  654.                                     if(TimeDateNode = CreateTimeDateNode(-1,-1,"",Count))
  655.                                     {
  656.                                         if(ReadChunkBytes(Handle,&TimeDateNode -> Header,sizeof(struct TimeDateHeader)) == sizeof(struct TimeDateHeader))
  657.                                         {
  658.                                             if(ReadChunkBytes(Handle,TimeDateNode -> Table,sizeof(struct TimeDate) * Count) == sizeof(struct TimeDate) * Count)
  659.                                             {
  660.                                                 AdaptTimeDateNode(TimeDateNode);
  661.  
  662.                                                 AddTail((struct List *)&PrivatePhonebook[Last] -> TimeDateList,&TimeDateNode -> VanillaNode);
  663.  
  664.                                                 LastHadTime = TRUE;
  665.                                             }
  666.                                             else
  667.                                             {
  668.                                                 Error = IoErr();
  669.  
  670.                                                 FreeTimeDateNode(TimeDateNode);
  671.                                             }
  672.                                         }
  673.                                         else
  674.                                         {
  675.                                             Error = IoErr();
  676.  
  677.                                             FreeTimeDateNode(TimeDateNode);
  678.                                         }
  679.                                     }
  680.                                 }
  681.                             }
  682.                         }
  683.  
  684.                         if(Size)
  685.                         {
  686.                             if(!LastHadTime && Last != -1)
  687.                             {
  688.                                 if(TimeDateNode = CreateTimeDateNode(-1,-1,"",2))
  689.                                     AddTail((struct List *)&PrivatePhonebook[Last] -> TimeDateList,&TimeDateNode -> VanillaNode);
  690.                             }
  691.  
  692.                             if(!BookHandle)
  693.                             {
  694.                                 struct timeval Now;
  695.                                 LONG i;
  696.  
  697.                                 GetSysTime(&Now);
  698.  
  699.                                 PhonebookID = Now . tv_secs;
  700.  
  701.                                 NewList((struct List *)&PhoneGroupList);
  702.  
  703.                                 if(Phonebook)
  704.                                     DeletePhonebook(Phonebook,PhoneSize,TRUE);
  705.  
  706.                                 Phonebook = PrivatePhonebook;
  707.                                 PhoneSize = PrivatePhoneSize;
  708.                                 PhonebookAutoDial = FALSE;
  709.                                 PhonebookAutoExit = FALSE;
  710.                                 PhonebookDefaultGroup = 0;
  711.  
  712.                                 NumPhoneEntries = Size;
  713.  
  714.                                 for(i = 0 ; i < NumPhoneEntries ; i++)
  715.                                     Phonebook[i] -> Header -> ID = PhonebookID++;
  716.                             }
  717.                             else
  718.                             {
  719.                                 struct timeval Now;
  720.                                 LONG i;
  721.  
  722.                                 GetSysTime(&Now);
  723.  
  724.                                 BookHandle -> PhonebookID = Now . tv_secs;
  725.  
  726.                                 if(BookHandle -> PhoneGroupList)
  727.                                     NewList((struct List *)BookHandle -> PhoneGroupList);
  728.  
  729.                                 if(BookHandle -> Phonebook)
  730.                                     DeletePhonebook(BookHandle -> Phonebook,BookHandle -> PhoneSize,TRUE);
  731.  
  732.                                 BookHandle -> Phonebook = PrivatePhonebook;
  733.                                 BookHandle -> PhoneSize = PrivatePhoneSize;
  734.                                 BookHandle -> DefaultGroup = 0;
  735.  
  736.                                 BookHandle -> NumPhoneEntries = Size;
  737.                                 BookHandle -> AutoDial = FALSE;
  738.                                 BookHandle -> AutoExit = FALSE;
  739.  
  740.                                 for(i = 0 ; i < BookHandle -> NumPhoneEntries ; i++)
  741.                                     BookHandle -> Phonebook[i] -> Header -> ID = BookHandle -> PhonebookID++;
  742.                             }
  743.  
  744.                             Success = TRUE;
  745.                         }
  746.                         else
  747.                         {
  748.                             if(PrivatePhoneSize)
  749.                             {
  750.                                 DeletePhonebook(PrivatePhonebook,PrivatePhoneSize,TRUE);
  751.  
  752.                                 Success = FALSE;
  753.                             }
  754.                         }
  755.  
  756.                         FreeDialList(TRUE);
  757.                     }
  758.  
  759.                     CloseIFF(Handle);
  760.                 }
  761.  
  762.                 Close(Handle -> iff_Stream);
  763.             }
  764.             else
  765.                 Error = IoErr();
  766.  
  767.             FreeIFF(Handle);
  768.         }
  769.         else
  770.             Error = ERR_NO_MEM;
  771.  
  772.         FreeVecPooled(OldConfig);
  773.     }
  774.     else
  775.         Error = ERR_NO_MEM;
  776.  
  777.     if(Error)
  778.         SetIoErr(Error);
  779.  
  780.     return(Success);
  781. }
  782.  
  783.     /* ReadConfig(STRPTR Name,struct Configuration *Config):
  784.      *
  785.      *    Read the configuration file, very much the same as ReadIFFData().
  786.      */
  787.  
  788. BYTE __regargs
  789. ReadOldConfig(STRPTR Name,struct Configuration *Config)
  790. {
  791.     struct IFFHandle    *Handle;
  792.     BYTE             Success = FALSE;
  793.     struct StoredProperty    *Prop;
  794.     struct TermInfo        *TermInfo;
  795.     struct OldConfiguration    *OldConfig;
  796.     LONG             Error;
  797.  
  798.     if(OldConfig = (struct OldConfiguration *)AllocVecPooled(sizeof(struct OldConfiguration),MEMF_ANY))
  799.     {
  800.         if(Handle = AllocIFF())
  801.         {
  802.             if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  803.             {
  804.                 InitIFFasDOS(Handle);
  805.  
  806.                 if(!(Error = OpenIFF(Handle,IFFF_READ)))
  807.                 {
  808.                     if(!(Error = PropChunks(Handle,(LONG *)VersionProps,1)))
  809.                     {
  810.                         if(!(Error = StopChunk(Handle,ID_TERM,ID_PREF)))
  811.                         {
  812.                             if(!ParseIFF(Handle,IFFPARSE_SCAN))
  813.                             {
  814.                                 if(Prop = FindProp(Handle,ID_TERM,ID_VERS))
  815.                                 {
  816.                                     TermInfo = (struct TermInfo *)Prop -> sp_Data;
  817.  
  818.                                     if(TermInfo -> Version == 2 && TermInfo -> Revision == 4)
  819.                                     {
  820.                                         struct ContextNode *Chunk = CurrentChunk(Handle);
  821.  
  822.                                         if(ReadChunkRecords(Handle,OldConfig,MIN(Chunk -> cn_Size,sizeof(struct OldConfiguration)),1) == 1)
  823.                                         {
  824.                                             if(ConvertConfig(OldConfig,Config,FALSE))
  825.                                                 Success = TRUE;
  826.                                         }
  827.                                         else
  828.                                             Error = IoErr();
  829.                                     }
  830.                                     else
  831.                                         Error = ERR_OUTDATED;
  832.                                 }
  833.                             }
  834.                         }
  835.                     }
  836.  
  837.                     CloseIFF(Handle);
  838.                 }
  839.  
  840.                 Close(Handle -> iff_Stream);
  841.             }
  842.             else
  843.                 Error = IoErr();
  844.  
  845.             FreeIFF(Handle);
  846.         }
  847.         else
  848.             Error = ERR_NO_MEM;
  849.  
  850.         FreeVecPooled(OldConfig);
  851.     }
  852.     else
  853.         Error = ERR_NO_MEM;
  854.  
  855.     if(Error)
  856.         SetIoErr(Error);
  857.  
  858.     return(Success);
  859. }
  860.